Node.js Oqimlari: Katta Hajmdagi Ma'lumotlarni Samarali Boshqarish

Ma'lumotlarga asoslangan ilovalarning zamonaviy davrida katta hajmdagi ma'lumotlar to'plamini samarali boshqarish juda muhimdir. Node.js o'zining bloklanmaydigan, hodisalarga asoslangan arxitekturasi bilan ma'lumotlarni boshqariladigan qismlarda qayta ishlash uchun kuchli mexanizmni taklif qiladi: Oqimlar. Ushbu maqola Node.js oqimlari dunyosiga chuqur kirib, resurslarni sarflamasdan katta hajmdagi ma'lumotlarni boshqara oladigan masshtablanuvchan va sezgir ilovalarni yaratish uchun ularning afzalliklari, turlari va amaliy qo'llanilishini o'rganadi.

Nima uchun oqimlardan foydalanish kerak?

An'anaga ko'ra, butun faylni o'qish yoki tarmoq so'rovidan barcha ma'lumotlarni qayta ishlashdan oldin qabul qilish, ayniqsa katta fayllar yoki uzluksiz ma'lumotlar oqimlari bilan ishlashda, unumdorlikda jiddiy muammolarga olib kelishi mumkin. Buferlash deb nomlanuvchi ushbu yondashuv sezilarli darajada xotirani iste'mol qilishi va ilovaning umumiy sezgirligini sekinlashtirishi mumkin. Oqimlar ma'lumotlarni kichik, mustaqil qismlarga bo'lib qayta ishlash orqali samaraliroq alternativani taqdim etadi, bu sizga butun ma'lumotlar to'plamining yuklanishini kutmasdan, ma'lumotlar paydo bo'lishi bilanoq ular bilan ishlashni boshlash imkonini beradi. Bu yondashuv ayniqsa quyidagilar uchun foydalidir:

• Xotirani boshqarish: Oqimlar ma'lumotlarni qismlarga bo'lib qayta ishlash orqali xotira sarfini sezilarli darajada kamaytiradi, bu esa ilovaning butun ma'lumotlar to'plamini birdaniga xotiraga yuklashining oldini oladi.
• Yaxshilangan unumdorlik: Ma'lumotlarni bosqichma-bosqich qayta ishlash orqali oqimlar kechikishni kamaytiradi va ilovaning sezgirligini yaxshilaydi, chunki ma'lumotlar kelishi bilan ularni qayta ishlash va uzatish mumkin.
• Kengaytirilgan masshtablanuvchanlik: Oqimlar ilovalarga kattaroq ma'lumotlar to'plamlari va ko'proq bir vaqtda so'rovlarni boshqarish imkonini beradi, bu ularni yanada masshtablanuvchan va mustahkam qiladi.
• Haqiqiy vaqtda ma'lumotlarni qayta ishlash: Oqimlar video, audio yoki sensor ma'lumotlarini striming qilish kabi real vaqtda ma'lumotlarni qayta ishlash stsenariylari uchun idealdir, bunda ma'lumotlarni uzluksiz qayta ishlash va uzatish kerak.

Oqim Turlarini Tushunish

Node.js har biri ma'lum bir maqsad uchun mo'ljallangan to'rtta asosiy oqim turini taqdim etadi:

1. O'qiladigan oqimlar: O'qiladigan oqimlar fayl, tarmoq ulanishi yoki ma'lumotlar generatori kabi manbadan ma'lumotlarni o'qish uchun ishlatiladi. Ular yangi ma'lumotlar mavjud bo'lganda 'data' hodisalarini va ma'lumot manbai to'liq iste'mol qilinganda 'end' hodisalarini chiqaradi.
2. Yoziladigan oqimlar: Yoziladigan oqimlar ma'lumotlarni fayl, tarmoq ulanishi yoki ma'lumotlar bazasi kabi manzilga yozish uchun ishlatiladi. Ular ma'lumotlarni yozish va xatolarni boshqarish usullarini taqdim etadi.
3. Dupleks oqimlar: Dupleks oqimlar ham o'qiladigan, ham yoziladigan bo'lib, ma'lumotlarning bir vaqtning o'zida ikkala yo'nalishda oqishiga imkon beradi. Ular odatda soketlar kabi tarmoq ulanishlari uchun ishlatiladi.
4. Transform oqimlari: Transform oqimlari - bu ma'lumotlarni o'tish jarayonida o'zgartirishi yoki transformatsiya qilishi mumkin bo'lgan maxsus dupleks oqim turidir. Ular siqish, shifrlash yoki ma'lumotlarni konvertatsiya qilish kabi vazifalar uchun idealdir.

O'qiladigan oqimlar bilan ishlash

O'qiladigan oqimlar turli manbalardan ma'lumotlarni o'qish uchun asosdir. Mana o'qiladigan oqim yordamida katta matnli faylni o'qishning asosiy misoli:

            const fs = require('fs');

const readableStream = fs.createReadStream('large-file.txt', { encoding: 'utf8', highWaterMark: 16384 });

readableStream.on('data', (chunk) => {
  console.log(`Received ${chunk.length} bytes of data`);
  // Bu yerda ma'lumot qismini qayta ishlang
});

readableStream.on('end', () => {
  console.log('Finished reading the file');
});

readableStream.on('error', (err) => {
  console.error('An error occurred:', err);
});

            

              
                Copy
              
            
          

Ushbu misolda:

• fs.createReadStream() ko'rsatilgan fayldan o'qiladigan oqim yaratadi.
• encoding opsiyasi faylning belgilar kodirovkasini (bu holda UTF-8) belgilaydi.
• highWaterMark opsiyasi bufer hajmini (bu holda 16KB) belgilaydi. Bu 'data' hodisalari sifatida chiqariladigan qismlarning hajmini aniqlaydi.
• 'data' hodisasini qayta ishlovchi har bir ma'lumot qismi mavjud bo'lganda chaqiriladi.
• 'end' hodisasini qayta ishlovchi butun fayl o'qib bo'lingandan so'ng chaqiriladi.
• 'error' hodisasini qayta ishlovchi o'qish jarayonida xatolik yuzaga kelsa chaqiriladi.

Yoziladigan oqimlar bilan ishlash

Yoziladigan oqimlar ma'lumotlarni turli manzillarga yozish uchun ishlatiladi. Mana yoziladigan oqim yordamida faylga ma'lumot yozish misoli:

            const fs = require('fs');

const writableStream = fs.createWriteStream('output.txt', { encoding: 'utf8' });

writableStream.write('This is the first line of data.\n');
writableStream.write('This is the second line of data.\n');
writableStream.write('This is the third line of data.\n');

writableStream.end(() => {
  console.log('Finished writing to the file');
});

writableStream.on('error', (err) => {
  console.error('An error occurred:', err);
});

            

              
                Copy
              
            
          

Ushbu misolda:

• fs.createWriteStream() ko'rsatilgan faylga yoziladigan oqim yaratadi.
• encoding opsiyasi faylning belgilar kodirovkasini (bu holda UTF-8) belgilaydi.
• writableStream.write() usuli ma'lumotlarni oqimga yozadi.
• writableStream.end() usuli oqimga boshqa ma'lumot yozilmasligini bildiradi va oqimni yopadi.
• 'error' hodisasini qayta ishlovchi yozish jarayonida xatolik yuzaga kelsa chaqiriladi.

Oqimlarni "Pipe" qilish (Ulash)

"Piping" o'qiladigan va yoziladigan oqimlarni ulash uchun kuchli mexanizm bo'lib, ma'lumotlarni bir oqimdan boshqasiga uzluksiz o'tkazish imkonini beradi. pipe() usuli oqimlarni ulash jarayonini soddalashtiradi, ma'lumotlar oqimini va xatolarni tarqatishni avtomatik ravishda boshqaradi. Bu ma'lumotlarni oqimli tarzda qayta ishlashning juda samarali usulidir.

            const fs = require('fs');
const zlib = require('zlib'); // Gzip siqish uchun

const readableStream = fs.createReadStream('large-file.txt');
const gzipStream = zlib.createGzip();
const writableStream = fs.createWriteStream('large-file.txt.gz');

readableStream.pipe(gzipStream).pipe(writableStream);

writableStream.on('finish', () => {
  console.log('File compressed successfully!');
});

            

              
                Copy
              
            
          

Ushbu misol "piping" yordamida katta faylni qanday siqishni ko'rsatadi:

• Kirish faylidan o'qiladigan oqim yaratiladi.
• zlib moduli yordamida gzip oqimi yaratiladi, u o'tayotgan ma'lumotlarni siqadi.
• Siqilgan ma'lumotlarni chiqish fayliga yozish uchun yoziladigan oqim yaratiladi.
• pipe() usuli oqimlarni ketma-ket ulaydi: o'qiladigan -> gzip -> yoziladigan.
• Yoziladigan oqimdagi 'finish' hodisasi barcha ma'lumotlar yozib bo'linganda ishga tushadi, bu muvaffaqiyatli siqishni bildiradi.

"Piping" teskari bosimni avtomatik ravishda boshqaradi. Teskari bosim o'qiladigan oqim yoziladigan oqim iste'mol qila oladiganidan tezroq ma'lumot ishlab chiqarganda yuzaga keladi. "Piping" yoziladigan oqim ko'proq ma'lumot qabul qilishga tayyor bo'lguncha ma'lumotlar oqimini to'xtatib, o'qiladigan oqimning yoziladigan oqimni haddan tashqari yuklashining oldini oladi. Bu resurslardan samarali foydalanishni ta'minlaydi va xotiraning to'lib ketishini oldini oladi.

Transform Oqimlari: Ma'lumotlarni Jarayonda O'zgartirish

Transform oqimlari ma'lumotlarni o'qiladigan oqimdan yoziladigan oqimga o'tish jarayonida o'zgartirish yoki transformatsiya qilish usulini taqdim etadi. Ular ma'lumotlarni konvertatsiya qilish, filtrlash yoki shifrlash kabi vazifalar uchun ayniqsa foydalidir. Transform oqimlari Dupleks oqimlaridan meros oladi va ma'lumotlarni transformatsiya qilishni amalga oshiradigan _transform() usulini qo'llaydi.

Mana matnni katta harflarga o'zgartiradigan transform oqimining misoli:

            const { Transform } = require('stream');

class UppercaseTransform extends Transform {
  constructor() {
    super();
  }

  _transform(chunk, encoding, callback) {
    const transformedChunk = chunk.toString().toUpperCase();
    callback(null, transformedChunk);
  }
}

const uppercaseTransform = new UppercaseTransform();

const readableStream = process.stdin; // Standart kiritishdan o'qish
const writableStream = process.stdout; // Standart chiqarishga yozish

readableStream.pipe(uppercaseTransform).pipe(writableStream);

            

              
                Copy
              
            
          

Ushbu misolda:

• Biz stream modulidagi Transform sinfini kengaytiradigan UppercaseTransform maxsus transform oqim sinfini yaratamiz.
• _transform() usuli har bir ma'lumot qismini katta harflarga o'zgartirish uchun qayta yoziladi.
• callback() funksiyasi transformatsiya tugallanganligini bildirish va transformatsiya qilingan ma'lumotlarni quvurdagi keyingi oqimga o'tkazish uchun chaqiriladi.
• Biz o'qiladigan oqim (standart kiritish) va yoziladigan oqim (standart chiqarish) namunalarini yaratamiz.
• Biz o'qiladigan oqimni transform oqimi orqali yoziladigan oqimga ulaymiz, bu kiritilgan matnni katta harflarga o'zgartiradi va uni konsolga chiqaradi.

Teskari Bosimni Boshqarish

Teskari bosim - bu bir oqimning boshqasini haddan tashqari yuklashini oldini oluvchi oqimlarni qayta ishlashdagi muhim tushuncha. O'qiladigan oqim yoziladigan oqim iste'mol qila oladiganidan tezroq ma'lumot ishlab chiqarganda teskari bosim yuzaga keladi. To'g'ri boshqarilmasa, teskari bosim xotiraning to'lib ketishiga va ilova barqarorligining buzilishiga olib kelishi mumkin. Node.js oqimlari teskari bosimni samarali boshqarish uchun mexanizmlarni taqdim etadi.

pipe() usuli teskari bosimni avtomatik ravishda boshqaradi. Yoziladigan oqim ko'proq ma'lumot qabul qilishga tayyor bo'lmaganda, o'qiladigan oqim yoziladigan oqim tayyor ekanligini bildirgunicha to'xtatib turiladi. Biroq, oqimlar bilan dasturiy ravishda ishlaganda (pipe() dan foydalanmasdan), siz teskari bosimni readable.pause() va readable.resume() usullari yordamida qo'lda boshqarishingiz kerak.

Mana teskari bosimni qo'lda qanday boshqarish misoli:

            const fs = require('fs');

const readableStream = fs.createReadStream('large-file.txt');
const writableStream = fs.createWriteStream('output.txt');

readableStream.on('data', (chunk) => {
  if (!writableStream.write(chunk)) {
    readableStream.pause();
  }
});

writableStream.on('drain', () => {
  readableStream.resume();
});

readableStream.on('end', () => {
  writableStream.end();
});

            

              
                Copy
              
            
          

Ushbu misolda:

• writableStream.write() usuli, agar oqimning ichki buferi to'la bo'lsa, false qiymatini qaytaradi, bu esa teskari bosim yuzaga kelayotganini bildiradi.
• writableStream.write() false qiymatini qaytarganda, biz o'qiladigan oqimni readableStream.pause() yordamida to'xtatamiz, toki u ko'proq ma'lumot ishlab chiqarmasin.
• 'drain' hodisasi yoziladigan oqim tomonidan uning buferi endi to'la bo'lmaganda chiqariladi, bu esa u ko'proq ma'lumot qabul qilishga tayyor ekanligini bildiradi.
• 'drain' hodisasi chiqarilganda, biz o'qiladigan oqimni readableStream.resume() yordamida qayta ishga tushiramiz, toki u ma'lumot ishlab chiqarishni davom ettirsin.

Node.js Oqimlarining Amaliy Qo'llanilishi

Node.js oqimlari katta hajmdagi ma'lumotlarni boshqarish muhim bo'lgan turli stsenariylarda qo'llaniladi. Mana bir nechta misollar:

• Fayllarni qayta ishlash: Katta fayllarni samarali o'qish, yozish, o'zgartirish va siqish. Masalan, katta log fayllarini qayta ishlash orqali maxsus ma'lumotlarni ajratib olish yoki turli fayl formatlari o'rtasida konvertatsiya qilish.
• Tarmoq aloqasi: Katta tarmoq so'rovlari va javoblarini boshqarish, masalan, video yoki audio ma'lumotlarini striming qilish. Video striming platformasini ko'rib chiqing, u yerda video ma'lumotlari foydalanuvchilarga qismlarga bo'lib uzatiladi.
• Ma'lumotlarni transformatsiya qilish: Ma'lumotlarni turli formatlar o'rtasida konvertatsiya qilish, masalan, CSV dan JSON ga yoki XML dan JSON ga. Ko'p manbalardan olingan ma'lumotlarni yagona formatga aylantirish kerak bo'lgan ma'lumotlar integratsiyasi stsenariysini o'ylab ko'ring.
• Haqiqiy vaqtda ma'lumotlarni qayta ishlash: Haqiqiy vaqtda ma'lumotlar oqimlarini qayta ishlash, masalan, IoT qurilmalaridan sensor ma'lumotlari yoki fond bozorlaridan moliyaviy ma'lumotlar. Minglab sensorlardan olingan ma'lumotlarni real vaqtda qayta ishlaydigan aqlli shahar ilovasini tasavvur qiling.
• Ma'lumotlar bazasi bilan o'zaro aloqalar: Ma'lumotlarni ma'lumotlar bazalariga va ulardan oqim bilan uzatish, ayniqsa MongoDB kabi NoSQL ma'lumotlar bazalari, ular ko'pincha katta hujjatlarni boshqaradi. Bu samarali ma'lumotlarni import va eksport qilish operatsiyalari uchun ishlatilishi mumkin.

Node.js Oqimlaridan Foydalanish bo'yicha Eng Yaxshi Amaliyotlar

Node.js oqimlaridan samarali foydalanish va ularning afzalliklarini maksimal darajada oshirish uchun quyidagi eng yaxshi amaliyotlarni ko'rib chiqing:

• To'g'ri oqim turini tanlang: Maxsus ma'lumotlarni qayta ishlash talablariga asoslanib, mos oqim turini (o'qiladigan, yoziladigan, dupleks yoki transform) tanlang.
• Xatolarni to'g'ri boshqaring: Oqimni qayta ishlash paytida yuzaga kelishi mumkin bo'lgan xatolarni ushlash va boshqarish uchun mustahkam xatolarni qayta ishlashni joriy qiling. Quvuringizdagi barcha oqimlarga xato tinglovchilarini ulang.
• Teskari bosimni boshqaring: Bir oqimning boshqasini haddan tashqari yuklashini oldini olish uchun teskari bosimni boshqarish mexanizmlarini joriy qiling, bu esa resurslardan samarali foydalanishni ta'minlaydi.
• Bufer hajmini optimallashtiring: Samarali xotirani boshqarish va ma'lumotlar oqimi uchun bufer hajmini optimallashtirish uchun highWaterMark opsiyasini sozlang. Xotiradan foydalanish va unumdorlik o'rtasidagi eng yaxshi muvozanatni topish uchun tajriba o'tkazing.
• Oddiy transformatsiyalar uchun "Piping" dan foydalaning: Oddiy ma'lumotlar transformatsiyalari va oqimlar o'rtasida ma'lumotlar uzatish uchun pipe() usulidan foydalaning.
• Murakkab mantiq uchun maxsus transform oqimlarini yarating: Murakkab ma'lumotlar transformatsiyalari uchun transformatsiya mantiqini inkapsulyatsiya qilish uchun maxsus transform oqimlarini yarating.
• Resurslarni tozalang: Oqimni qayta ishlash tugagandan so'ng, fayllarni yopish va xotirani bo'shatish kabi resurslarni to'g'ri tozalashni ta'minlang.
• Oqim unumdorligini kuzatib boring: Muammoli joylarni aniqlash va ma'lumotlarni qayta ishlash samaradorligini optimallashtirish uchun oqim unumdorligini kuzatib boring. Node.js ning o'rnatilgan profiler vositasi yoki uchinchi tomon monitoring xizmatlaridan foydalaning.

Xulosa

Node.js oqimlari katta hajmdagi ma'lumotlarni samarali boshqarish uchun kuchli vositadir. Ma'lumotlarni boshqariladigan qismlarga bo'lib qayta ishlash orqali oqimlar xotira sarfini sezilarli darajada kamaytiradi, unumdorlikni oshiradi va masshtablanuvchanlikni yaxshilaydi. Turli oqim turlarini tushunish, "piping"ni o'zlashtirish va teskari bosimni boshqarish - bu katta hajmdagi ma'lumotlarni osonlik bilan boshqara oladigan mustahkam va samarali Node.js ilovalarini yaratish uchun zarurdir. Ushbu maqolada bayon qilingan eng yaxshi amaliyotlarga rioya qilish orqali siz Node.js oqimlarining to'liq salohiyatidan foydalanishingiz va keng ko'lamli ma'lumot talab qiladigan vazifalar uchun yuqori unumdorlikka ega, masshtablanuvchan ilovalarni yaratishingiz mumkin.

Node.js dasturlash ishingizda oqimlarni qo'llang va ilovalaringizda samaradorlik va masshtablanuvchanlikning yangi darajasini oching. Ma'lumotlar hajmi o'sishda davom etar ekan, ma'lumotlarni samarali qayta ishlash qobiliyati tobora muhimroq bo'lib boradi va Node.js oqimlari ushbu qiyinchiliklarni yengish uchun mustahkam asos yaratadi.